package com.zhouyu.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.security.MessageDigest;

/**
 * @ClassName: HashKitCrypto
 * @author zhongjyuan
 * @date 2020年7月14日 上午10:19:59
 * @Description: TODO: 哈希加解密
 * 
 */
@Component
public class HashKitCrypto {
	private static Logger log = LoggerFactory.getLogger(HashKitCrypto.class);
	/**
	 * @author zhongjyuan
	 * @data 2020年7月14日上午10:20:11
	 * @Fields random : TODO: 随机对象
	 */
	private static final java.security.SecureRandom random = new java.security.SecureRandom();

	private static final char[] HEX_DIGITS = "0123456789abcdef".toCharArray();
	private static final char[] CHAR_ARRAY = "_-0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
			.toCharArray();

	/**
	 * @Title: md5 @Author zhongjyuan @Data 2020年7月14日上午10:20:32 @Description:
	 * TODO(使用MD5算法对字符串参数进行哈希处理) @param @param srcStr 原字符串 @param @return
	 * 参数说明 @return String 返回md5哈希处理后的字符串 @throws
	 */
	public static String md5(String srcStr) {
		return hash("MD5", srcStr);
	}

	/**
	 * @Title: sha1 @Author zhongjyuan @Data 2020年7月14日上午10:20:56 @Description:
	 * TODO(使用sha1算法对字符串参数进行哈希处理) @param @param srcStr 原字符串 @param @return
	 * 参数说明 @return String 返回sha1哈希处理后的字符串 @throws
	 */
	public static String sha1(String srcStr) {
		return hash("SHA-1", srcStr);
	}

	/**
	 * @Title: sha256 @Author zhongjyuan @Data 2020年7月14日上午10:21:25 @Description:
	 * TODO(使用sha256算法对字符串参数进行哈希处理) @param @param srcStr 原字符串 @param @return
	 * 参数说明 @return String 返回sha256哈希处理后的字符串 @throws
	 */
	public static String sha256(String srcStr) {
		return hash("SHA-256", srcStr);
	}

	/**
	 * @Title: sha384 @Author zhongjyuan @Data 2020年7月14日上午10:21:47 @Description:
	 * TODO(使用sha384算法对字符串参数进行哈希处理) @param @param srcStr 原字符串 @param @return
	 * 参数说明 @return String 返回sha384哈希处理后的字符串 @throws
	 */
	public static String sha384(String srcStr) {
		return hash("SHA-384", srcStr);
	}

	/**
	 * @Title: sha512 @Author zhongjyuan @Data 2020年7月14日上午10:22:06 @Description:
	 * TODO(使用sha512算法对字符串参数进行哈希处理) @param @param srcStr 原字符串 @param @return
	 * 参数说明 @return String 返回sha512哈希处理后的字符串 @throws
	 */
	public static String sha512(String srcStr) {
		return hash("SHA-512", srcStr);
	}

	/**
	 * @Title: hash @Author zhongjyuan @Data 2020年7月14日上午10:22:27 @Description:
	 * TODO(对原字符串使用指定加密算法进行哈希处理) @param @param algorithm 加密算法 @param @param srcStr
	 * 原字符串 @param @return 参数说明 @return String 返回哈希处理后的字符串 @throws
	 */
	public static String hash(String algorithm, String srcStr) {
		log.trace("======HashKitCrypto======hash()======begin======");
		try {
			MessageDigest md = MessageDigest.getInstance(algorithm);
			byte[] bytes = md.digest(srcStr.getBytes("utf-8"));
			return toHex(bytes);
		} catch (Exception e) {
			log.trace("======HashKitCrypto======hash()======exception======");
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Title: toHex @Author zhongjyuan @Data 2020年7月14日上午10:22:57 @Description:
	 * TODO(把字节数组转为16进制字符串) @param @param bytes @param @return 参数说明 @return String
	 * 返回类型 @throws
	 */
	private static String toHex(byte[] bytes) {
		StringBuilder ret = new StringBuilder(bytes.length * 2);
		for (int i = 0; i < bytes.length; i++) {
			ret.append(HEX_DIGITS[(bytes[i] >> 4) & 0x0f]);
			ret.append(HEX_DIGITS[bytes[i] & 0x0f]);
		}
		return ret.toString();
	}

	/**
	 * @Title: generateSalt @Author zhongjyuan @Data
	 * 2020年7月14日上午10:23:14 @Description: TODO(生成盐值 md5 128bit 16bytes sha1 160bit
	 * 20bytes sha256 256bit 32bytes sha384 384bit 48bytes sha512 512bit
	 * 64bytes) @param @param saltLength 盐值长度 @param @return 参数说明 @return String
	 * 返回生成的盐值 @throws
	 */
	public static String generateSalt(int saltLength) {
		log.trace("======HashKitCrypto======generateSalt()======begin======");
		StringBuilder salt = new StringBuilder();
		for (int i = 0; i < saltLength; i++) {
			salt.append(CHAR_ARRAY[random.nextInt(CHAR_ARRAY.length)]);
		}
		return salt.toString();
	}

	/**
	 * @Title: generateSaltForSha256 @Author zhongjyuan @Data
	 * 2020年7月14日上午10:23:59 @Description: TODO(为Sha256加密算法生成32位长度的盐值) @param @return
	 * 参数说明 @return String 返回类型 @throws
	 */
	public static String generateSaltForSha256() {
		return generateSalt(32);
	}

	/**
	 * @Title: generateSaltForSha512 @Author zhongjyuan @Data
	 * 2020年7月14日上午10:24:14 @Description: TODO(为Sha512加密算法生成64位长度的盐值) @param @return
	 * 参数说明 @return String 返回类型 @throws
	 */
	public static String generateSaltForSha512() {
		return generateSalt(64);
	}

	/**
	 * @Title: slowEquals @Author zhongjyuan @Data
	 * 2020年7月14日上午10:24:29 @Description: TODO(比较2个字节数组是否相等) @param @param a
	 * 待比较字节数组 @param @param b 待比较字节数组 @param @return 参数说明 @return boolean
	 * 相等返回true，否则返回false @throws
	 */
	public static boolean slowEquals(byte[] a, byte[] b) {
		if (a == null || b == null) {
			return false;
		}

		int diff = a.length ^ b.length;
		for (int i = 0; i < a.length && i < b.length; i++) {
			diff |= a[i] ^ b[i];
		}
		return diff == 0;
	}

	/**
	 * @Title: main @Author zhongjyuan @Data 2020年7月14日上午10:24:53 @Description:
	 * TODO(这里用一句话描述这个方法的作用) @param @param args 参数说明 @return void 返回类型 @throws
	 */
	public static void main(String[] args) {
		String md5Str = "zhongjyuan";
		String md5result = HashKitCrypto.md5(md5Str);
		System.out.println("md5 result is " + md5result);

		String sha1Str = "zhongjyuan";
		String sha1result = HashKitCrypto.sha1(sha1Str);
		System.out.println("sha1 result is " + sha1result);

		String sha256Str = "zhongjyuan";
		String sha256result = HashKitCrypto.sha256(sha256Str);
		System.out.println("sha256 result is " + sha256result);

		String sha384Str = "zhongjyuan";
		String sha384result = HashKitCrypto.sha384(sha384Str);
		System.out.println("sha384 result is " + sha384result);

		String sha512Str = "zhongjyuan";
		String sha512result = HashKitCrypto.sha512(sha512Str);
		System.out.println("sha512 result is " + sha512result);
	}
}
